{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Fully-Connected Neural Nets\n",
    "In the previous homework you implemented a fully-connected two-layer neural network on CIFAR-10. The implementation was simple but not very modular since the loss and gradient were computed in a single monolithic function. This is manageable for a simple two-layer network, but would become impractical as we move to bigger models. Ideally we want to build networks using a more modular design so that we can implement different layer types in isolation and then snap them together into models with different architectures.\n",
    "\n",
    "In this exercise we will implement fully-connected networks using a more modular approach. For each layer we will implement a `forward` and a `backward` function. The `forward` function will receive inputs, weights, and other parameters and will return both an output and a `cache` object storing data needed for the backward pass, like this:\n",
    "\n",
    "```python\n",
    "def layer_forward(x, w):\n",
    "  \"\"\" Receive inputs x and weights w \"\"\"\n",
    "  # Do some computations ...\n",
    "  z = # ... some intermediate value\n",
    "  # Do some more computations ...\n",
    "  out = # the output\n",
    "   \n",
    "  cache = (x, w, z, out) # Values we need to compute gradients\n",
    "   \n",
    "  return out, cache\n",
    "```\n",
    "\n",
    "The backward pass will receive upstream derivatives and the `cache` object, and will return gradients with respect to the inputs and weights, like this:\n",
    "\n",
    "```python\n",
    "def layer_backward(dout, cache):\n",
    "  \"\"\"\n",
    "  Receive dout (derivative of loss with respect to outputs) and cache,\n",
    "  and compute derivative with respect to inputs.\n",
    "  \"\"\"\n",
    "  # Unpack cache values\n",
    "  x, w, z, out = cache\n",
    "  \n",
    "  # Use values in cache to compute derivatives\n",
    "  dx = # Derivative of loss with respect to x\n",
    "  dw = # Derivative of loss with respect to w\n",
    "  \n",
    "  return dx, dw\n",
    "```\n",
    "\n",
    "After implementing a bunch of layers this way, we will be able to easily combine them to build classifiers with different architectures.\n",
    "\n",
    "In addition to implementing fully-connected networks of arbitrary depth, we will also explore different update rules for optimization, and introduce Dropout as a regularizer and Batch/Layer Normalization as a tool to more efficiently optimize deep networks.\n",
    "  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "# As usual, a bit of setup\n",
    "from __future__ import print_function\n",
    "import time\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "from cs231n.classifiers.fc_net import *\n",
    "from cs231n.data_utils import get_CIFAR10_data\n",
    "from cs231n.gradient_check import eval_numerical_gradient, eval_numerical_gradient_array\n",
    "from cs231n.solver import Solver\n",
    "\n",
    "%matplotlib inline\n",
    "plt.rcParams['figure.figsize'] = (10.0, 8.0) # set default size of plots\n",
    "plt.rcParams['image.interpolation'] = 'nearest'\n",
    "plt.rcParams['image.cmap'] = 'gray'\n",
    "\n",
    "# for auto-reloading external modules\n",
    "# see http://stackoverflow.com/questions/1907993/autoreload-of-modules-in-ipython\n",
    "%load_ext autoreload\n",
    "%autoreload 2\n",
    "\n",
    "def rel_error(x, y):\n",
    "  \"\"\" returns relative error \"\"\"\n",
    "  return np.max(np.abs(x - y) / (np.maximum(1e-8, np.abs(x) + np.abs(y))))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "('X_train: ', (49000, 3, 32, 32))\n",
      "('y_train: ', (49000,))\n",
      "('X_val: ', (1000, 3, 32, 32))\n",
      "('y_val: ', (1000,))\n",
      "('X_test: ', (1000, 3, 32, 32))\n",
      "('y_test: ', (1000,))\n"
     ]
    }
   ],
   "source": [
    "# Load the (preprocessed) CIFAR10 data.\n",
    "\n",
    "data = get_CIFAR10_data()\n",
    "for k, v in list(data.items()):\n",
    "  print(('%s: ' % k, v.shape))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Affine layer: foward\n",
    "Open the file `cs231n/layers.py` and implement the `affine_forward` function.\n",
    "\n",
    "Once you are done you can test your implementaion by running the following:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Testing affine_forward function:\n",
      "difference:  9.769847728806635e-10\n"
     ]
    }
   ],
   "source": [
    "# Test the affine_forward function\n",
    "\n",
    "num_inputs = 2\n",
    "input_shape = (4, 5, 6)\n",
    "output_dim = 3\n",
    "\n",
    "input_size = num_inputs * np.prod(input_shape)\n",
    "weight_size = output_dim * np.prod(input_shape)\n",
    "\n",
    "x = np.linspace(-0.1, 0.5, num=input_size).reshape(num_inputs, *input_shape)\n",
    "w = np.linspace(-0.2, 0.3, num=weight_size).reshape(np.prod(input_shape), output_dim)\n",
    "b = np.linspace(-0.3, 0.1, num=output_dim)\n",
    "\n",
    "out, _ = affine_forward(x, w, b)\n",
    "correct_out = np.array([[ 1.49834967,  1.70660132,  1.91485297],\n",
    "                        [ 3.25553199,  3.5141327,   3.77273342]])\n",
    "\n",
    "# Compare your output with ours. The error should be around e-9 or less.\n",
    "print('Testing affine_forward function:')\n",
    "print('difference: ', rel_error(out, correct_out))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Affine layer: backward\n",
    "Now implement the `affine_backward` function and test your implementation using numeric gradient checking."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Testing affine_backward function:\n",
      "dx error:  5.399100368651805e-11\n",
      "dw error:  9.904211865398145e-11\n",
      "db error:  2.4122867568119087e-11\n"
     ]
    }
   ],
   "source": [
    "# Test the affine_backward function\n",
    "np.random.seed(231)\n",
    "x = np.random.randn(10, 2, 3)\n",
    "w = np.random.randn(6, 5)\n",
    "b = np.random.randn(5)\n",
    "dout = np.random.randn(10, 5)\n",
    "\n",
    "dx_num = eval_numerical_gradient_array(lambda x: affine_forward(x, w, b)[0], x, dout)\n",
    "dw_num = eval_numerical_gradient_array(lambda w: affine_forward(x, w, b)[0], w, dout)\n",
    "db_num = eval_numerical_gradient_array(lambda b: affine_forward(x, w, b)[0], b, dout)\n",
    "\n",
    "_, cache = affine_forward(x, w, b)\n",
    "dx, dw, db = affine_backward(dout, cache)\n",
    "\n",
    "# The error should be around e-10 or less\n",
    "print('Testing affine_backward function:')\n",
    "print('dx error: ', rel_error(dx_num, dx))\n",
    "print('dw error: ', rel_error(dw_num, dw))\n",
    "print('db error: ', rel_error(db_num, db))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# ReLU activation: forward\n",
    "Implement the forward pass for the ReLU activation function in the `relu_forward` function and test your implementation using the following:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Testing relu_forward function:\n",
      "difference:  4.999999798022158e-08\n"
     ]
    }
   ],
   "source": [
    "# Test the relu_forward function\n",
    "\n",
    "x = np.linspace(-0.5, 0.5, num=12).reshape(3, 4)\n",
    "\n",
    "out, _ = relu_forward(x)\n",
    "correct_out = np.array([[ 0.,          0.,          0.,          0.,        ],\n",
    "                        [ 0.,          0.,          0.04545455,  0.13636364,],\n",
    "                        [ 0.22727273,  0.31818182,  0.40909091,  0.5,       ]])\n",
    "\n",
    "# Compare your output with ours. The error should be on the order of e-8\n",
    "print('Testing relu_forward function:')\n",
    "print('difference: ', rel_error(out, correct_out))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# ReLU activation: backward\n",
    "Now implement the backward pass for the ReLU activation function in the `relu_backward` function and test your implementation using numeric gradient checking:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Testing relu_backward function:\n",
      "dx error:  3.2756349136310288e-12\n"
     ]
    }
   ],
   "source": [
    "np.random.seed(231)\n",
    "x = np.random.randn(10, 10)\n",
    "dout = np.random.randn(*x.shape)\n",
    "\n",
    "dx_num = eval_numerical_gradient_array(lambda x: relu_forward(x)[0], x, dout)\n",
    "\n",
    "_, cache = relu_forward(x)\n",
    "dx = relu_backward(dout, cache)\n",
    "\n",
    "# The error should be on the order of e-12\n",
    "print('Testing relu_backward function:')\n",
    "print('dx error: ', rel_error(dx_num, dx))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Inline Question 1: \n",
    "\n",
    "We've only asked you to implement ReLU, but there are a number of different activation functions that one could use in neural networks, each with its pros and cons. In particular, an issue commonly seen with activation functions is getting zero (or close to zero) gradient flow during backpropagation. Which of the following activation functions have this problem? If you consider these functions in the one dimensional case, what types of input would lead to this behaviour?\n",
    "1. Sigmoid\n",
    "2. ReLU\n",
    "3. Leaky ReLU"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Answer:\n",
    "[FILL THIS IN]\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# \"Sandwich\" layers\n",
    "There are some common patterns of layers that are frequently used in neural nets. For example, affine layers are frequently followed by a ReLU nonlinearity. To make these common patterns easy, we define several convenience layers in the file `cs231n/layer_utils.py`.\n",
    "\n",
    "For now take a look at the `affine_relu_forward` and `affine_relu_backward` functions, and run the following to numerically gradient check the backward pass:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Testing affine_relu_forward and affine_relu_backward:\n",
      "dx error:  6.750562121603446e-11\n",
      "dw error:  8.162015570444288e-11\n",
      "db error:  7.826724021458994e-12\n"
     ]
    }
   ],
   "source": [
    "from cs231n.layer_utils import affine_relu_forward, affine_relu_backward\n",
    "np.random.seed(231)\n",
    "x = np.random.randn(2, 3, 4)\n",
    "w = np.random.randn(12, 10)\n",
    "b = np.random.randn(10)\n",
    "dout = np.random.randn(2, 10)\n",
    "\n",
    "out, cache = affine_relu_forward(x, w, b)\n",
    "dx, dw, db = affine_relu_backward(dout, cache)\n",
    "\n",
    "dx_num = eval_numerical_gradient_array(lambda x: affine_relu_forward(x, w, b)[0], x, dout)\n",
    "dw_num = eval_numerical_gradient_array(lambda w: affine_relu_forward(x, w, b)[0], w, dout)\n",
    "db_num = eval_numerical_gradient_array(lambda b: affine_relu_forward(x, w, b)[0], b, dout)\n",
    "\n",
    "# Relative error should be around e-10 or less\n",
    "print('Testing affine_relu_forward and affine_relu_backward:')\n",
    "print('dx error: ', rel_error(dx_num, dx))\n",
    "print('dw error: ', rel_error(dw_num, dw))\n",
    "print('db error: ', rel_error(db_num, db))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Loss layers: Softmax and SVM\n",
    "You implemented these loss functions in the last assignment, so we'll give them to you for free here. You should still make sure you understand how they work by looking at the implementations in `cs231n/layers.py`.\n",
    "\n",
    "You can make sure that the implementations are correct by running the following:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Testing svm_loss:\n",
      "loss:  8.999602749096233\n",
      "dx error:  1.4021566006651672e-09\n",
      "\n",
      "Testing softmax_loss:\n",
      "loss:  2.302545844500738\n",
      "dx error:  9.384673161989355e-09\n"
     ]
    }
   ],
   "source": [
    "np.random.seed(231)\n",
    "num_classes, num_inputs = 10, 50\n",
    "x = 0.001 * np.random.randn(num_inputs, num_classes)\n",
    "y = np.random.randint(num_classes, size=num_inputs)\n",
    "\n",
    "dx_num = eval_numerical_gradient(lambda x: svm_loss(x, y)[0], x, verbose=False)\n",
    "loss, dx = svm_loss(x, y)\n",
    "\n",
    "# Test svm_loss function. Loss should be around 9 and dx error should be around the order of e-9\n",
    "print('Testing svm_loss:')\n",
    "print('loss: ', loss)\n",
    "print('dx error: ', rel_error(dx_num, dx))\n",
    "\n",
    "dx_num = eval_numerical_gradient(lambda x: softmax_loss(x, y)[0], x, verbose=False)\n",
    "loss, dx = softmax_loss(x, y)\n",
    "\n",
    "# Test softmax_loss function. Loss should be close to 2.3 and dx error should be around e-8\n",
    "print('\\nTesting softmax_loss:')\n",
    "print('loss: ', loss)\n",
    "print('dx error: ', rel_error(dx_num, dx))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Two-layer network\n",
    "In the previous assignment you implemented a two-layer neural network in a single monolithic class. Now that you have implemented modular versions of the necessary layers, you will reimplement the two layer network using these modular implementations.\n",
    "\n",
    "Open the file `cs231n/classifiers/fc_net.py` and complete the implementation of the `TwoLayerNet` class. This class will serve as a model for the other networks you will implement in this assignment, so read through it to make sure you understand the API. You can run the cell below to test your implementation."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Testing initialization ... \n",
      "Testing test-time forward pass ... \n",
      "Testing training loss (no regularization)\n",
      "Running numeric gradient check with reg =  0.0\n",
      "W1 relative error: 1.22e-08\n",
      "W2 relative error: 3.48e-10\n",
      "b1 relative error: 6.55e-09\n",
      "b2 relative error: 4.33e-10\n",
      "Running numeric gradient check with reg =  0.7\n",
      "W1 relative error: 8.18e-07\n",
      "W2 relative error: 2.85e-08\n",
      "b1 relative error: 1.09e-09\n",
      "b2 relative error: 7.76e-10\n"
     ]
    }
   ],
   "source": [
    "np.random.seed(231)\n",
    "N, D, H, C = 3, 5, 50, 7\n",
    "X = np.random.randn(N, D)\n",
    "y = np.random.randint(C, size=N)\n",
    "\n",
    "std = 1e-3\n",
    "model = TwoLayerNet(input_dim=D, hidden_dim=H, num_classes=C, weight_scale=std)\n",
    "\n",
    "print('Testing initialization ... ')\n",
    "W1_std = abs(model.params['W1'].std() - std)\n",
    "b1 = model.params['b1']\n",
    "W2_std = abs(model.params['W2'].std() - std)\n",
    "b2 = model.params['b2']\n",
    "assert W1_std < std / 10, 'First layer weights do not seem right'\n",
    "assert np.all(b1 == 0), 'First layer biases do not seem right'\n",
    "assert W2_std < std / 10, 'Second layer weights do not seem right'\n",
    "assert np.all(b2 == 0), 'Second layer biases do not seem right'\n",
    "\n",
    "print('Testing test-time forward pass ... ')\n",
    "model.params['W1'] = np.linspace(-0.7, 0.3, num=D*H).reshape(D, H)\n",
    "model.params['b1'] = np.linspace(-0.1, 0.9, num=H)\n",
    "model.params['W2'] = np.linspace(-0.3, 0.4, num=H*C).reshape(H, C)\n",
    "model.params['b2'] = np.linspace(-0.9, 0.1, num=C)\n",
    "X = np.linspace(-5.5, 4.5, num=N*D).reshape(D, N).T\n",
    "scores = model.loss(X)\n",
    "correct_scores = np.asarray(\n",
    "  [[11.53165108,  12.2917344,   13.05181771,  13.81190102,  14.57198434, 15.33206765,  16.09215096],\n",
    "   [12.05769098,  12.74614105,  13.43459113,  14.1230412,   14.81149128, 15.49994135,  16.18839143],\n",
    "   [12.58373087,  13.20054771,  13.81736455,  14.43418138,  15.05099822, 15.66781506,  16.2846319 ]])\n",
    "scores_diff = np.abs(scores - correct_scores).sum()\n",
    "assert scores_diff < 1e-6, 'Problem with test-time forward pass'\n",
    "\n",
    "print('Testing training loss (no regularization)')\n",
    "y = np.asarray([0, 5, 1])\n",
    "loss, grads = model.loss(X, y)\n",
    "correct_loss = 3.4702243556\n",
    "assert abs(loss - correct_loss) < 1e-10, 'Problem with training-time loss'\n",
    "\n",
    "model.reg = 1.0\n",
    "loss, grads = model.loss(X, y)\n",
    "correct_loss = 26.5948426952\n",
    "assert abs(loss - correct_loss) < 1e-10, 'Problem with regularization loss'\n",
    "\n",
    "# Errors should be around e-7 or less\n",
    "for reg in [0.0, 0.7]:\n",
    "  print('Running numeric gradient check with reg = ', reg)\n",
    "  model.reg = reg\n",
    "  loss, grads = model.loss(X, y)\n",
    "\n",
    "  for name in sorted(grads):\n",
    "    f = lambda _: model.loss(X, y)[0]\n",
    "    grad_num = eval_numerical_gradient(f, model.params[name], verbose=False)\n",
    "    print('%s relative error: %.2e' % (name, rel_error(grad_num, grads[name])))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Solver\n",
    "In the previous assignment, the logic for training models was coupled to the models themselves. Following a more modular design, for this assignment we have split the logic for training models into a separate class.\n",
    "\n",
    "Open the file `cs231n/solver.py` and read through it to familiarize yourself with the API. After doing so, use a `Solver` instance to train a `TwoLayerNet` that achieves at least `50%` accuracy on the validation set."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(Iteration 1 / 4900) loss: 2.304060\n",
      "(Epoch 0 / 10) train acc: 0.116000; val_acc: 0.094000\n",
      "(Iteration 101 / 4900) loss: 1.829613\n",
      "(Iteration 201 / 4900) loss: 1.857390\n",
      "(Iteration 301 / 4900) loss: 1.744448\n",
      "(Iteration 401 / 4900) loss: 1.420187\n",
      "(Epoch 1 / 10) train acc: 0.407000; val_acc: 0.422000\n",
      "(Iteration 501 / 4900) loss: 1.565913\n",
      "(Iteration 601 / 4900) loss: 1.700510\n",
      "(Iteration 701 / 4900) loss: 1.732213\n",
      "(Iteration 801 / 4900) loss: 1.688361\n",
      "(Iteration 901 / 4900) loss: 1.439529\n",
      "(Epoch 2 / 10) train acc: 0.497000; val_acc: 0.468000\n",
      "(Iteration 1001 / 4900) loss: 1.385772\n",
      "(Iteration 1101 / 4900) loss: 1.278401\n",
      "(Iteration 1201 / 4900) loss: 1.641580\n",
      "(Iteration 1301 / 4900) loss: 1.438847\n",
      "(Iteration 1401 / 4900) loss: 1.172536\n",
      "(Epoch 3 / 10) train acc: 0.490000; val_acc: 0.466000\n",
      "(Iteration 1501 / 4900) loss: 1.346286\n",
      "(Iteration 1601 / 4900) loss: 1.268492\n",
      "(Iteration 1701 / 4900) loss: 1.318215\n",
      "(Iteration 1801 / 4900) loss: 1.395750\n",
      "(Iteration 1901 / 4900) loss: 1.338233\n",
      "(Epoch 4 / 10) train acc: 0.532000; val_acc: 0.497000\n",
      "(Iteration 2001 / 4900) loss: 1.343165\n",
      "(Iteration 2101 / 4900) loss: 1.393173\n",
      "(Iteration 2201 / 4900) loss: 1.276734\n",
      "(Iteration 2301 / 4900) loss: 1.287951\n",
      "(Iteration 2401 / 4900) loss: 1.352778\n",
      "(Epoch 5 / 10) train acc: 0.525000; val_acc: 0.475000\n",
      "(Iteration 2501 / 4900) loss: 1.390234\n",
      "(Iteration 2601 / 4900) loss: 1.276361\n",
      "(Iteration 2701 / 4900) loss: 1.111768\n",
      "(Iteration 2801 / 4900) loss: 1.271688\n",
      "(Iteration 2901 / 4900) loss: 1.272039\n",
      "(Epoch 6 / 10) train acc: 0.546000; val_acc: 0.509000\n",
      "(Iteration 3001 / 4900) loss: 1.304489\n",
      "(Iteration 3101 / 4900) loss: 1.346667\n",
      "(Iteration 3201 / 4900) loss: 1.325510\n",
      "(Iteration 3301 / 4900) loss: 1.392728\n",
      "(Iteration 3401 / 4900) loss: 1.402001\n",
      "(Epoch 7 / 10) train acc: 0.567000; val_acc: 0.505000\n",
      "(Iteration 3501 / 4900) loss: 1.319024\n",
      "(Iteration 3601 / 4900) loss: 1.153287\n",
      "(Iteration 3701 / 4900) loss: 1.180922\n",
      "(Iteration 3801 / 4900) loss: 1.093164\n",
      "(Iteration 3901 / 4900) loss: 1.135902\n",
      "(Epoch 8 / 10) train acc: 0.568000; val_acc: 0.490000\n",
      "(Iteration 4001 / 4900) loss: 1.191735\n",
      "(Iteration 4101 / 4900) loss: 1.359396\n",
      "(Iteration 4201 / 4900) loss: 1.227283\n",
      "(Iteration 4301 / 4900) loss: 1.024113\n",
      "(Iteration 4401 / 4900) loss: 1.327583\n",
      "(Epoch 9 / 10) train acc: 0.592000; val_acc: 0.504000\n",
      "(Iteration 4501 / 4900) loss: 0.963330\n",
      "(Iteration 4601 / 4900) loss: 1.445619\n",
      "(Iteration 4701 / 4900) loss: 1.007542\n",
      "(Iteration 4801 / 4900) loss: 1.005175\n",
      "(Epoch 10 / 10) train acc: 0.611000; val_acc: 0.512000\n"
     ]
    }
   ],
   "source": [
    "model = TwoLayerNet()\n",
    "solver = None\n",
    "\n",
    "##############################################################################\n",
    "# TODO: Use a Solver instance to train a TwoLayerNet that achieves at least  #\n",
    "# 50% accuracy on the validation set.                                        #\n",
    "##############################################################################\n",
    "solver = Solver(model, data,\n",
    "                    update_rule='sgd',\n",
    "                    optim_config={\n",
    "                      'learning_rate': 1e-3,\n",
    "                    },\n",
    "                    lr_decay=0.95,\n",
    "                    num_epochs=10, batch_size=100,\n",
    "                    print_every=100)\n",
    "solver.train()\n",
    "##############################################################################\n",
    "#                             END OF YOUR CODE                               #\n",
    "##############################################################################"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7f9159b52ac8>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Run this cell to visualize training loss and train / val accuracy\n",
    "\n",
    "plt.subplot(2, 1, 1)\n",
    "plt.title('Training loss')\n",
    "plt.plot(solver.loss_history, 'o')\n",
    "plt.xlabel('Iteration')\n",
    "\n",
    "plt.subplot(2, 1, 2)\n",
    "plt.title('Accuracy')\n",
    "plt.plot(solver.train_acc_history, '-o', label='train')\n",
    "plt.plot(solver.val_acc_history, '-o', label='val')\n",
    "plt.plot([0.5] * len(solver.val_acc_history), 'k--')\n",
    "plt.xlabel('Epoch')\n",
    "plt.legend(loc='lower right')\n",
    "plt.gcf().set_size_inches(15, 12)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Multilayer network\n",
    "Next you will implement a fully-connected network with an arbitrary number of hidden layers.\n",
    "\n",
    "Read through the `FullyConnectedNet` class in the file `cs231n/classifiers/fc_net.py`.\n",
    "\n",
    "Implement the initialization, the forward pass, and the backward pass. For the moment don't worry about implementing dropout or batch/layer normalization; we will add those features soon."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Initial loss and gradient check"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As a sanity check, run the following to check the initial loss and to gradient check the network both with and without regularization. Do the initial losses seem reasonable?\n",
    "\n",
    "For gradient checking, you should expect to see errors around 1e-7 or less."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Running check with reg =  0\n",
      "Initial loss:  2.3004790897684924\n",
      "W1 relative error: 1.48e-07\n",
      "W2 relative error: 2.21e-05\n",
      "W3 relative error: 3.53e-07\n",
      "b1 relative error: 5.38e-09\n",
      "b2 relative error: 2.09e-09\n",
      "b3 relative error: 5.80e-11\n",
      "Running check with reg =  3.14\n",
      "Initial loss:  7.052114776533016\n",
      "W1 relative error: 7.36e-09\n",
      "W2 relative error: 6.87e-08\n",
      "W3 relative error: 3.48e-08\n",
      "b1 relative error: 1.48e-08\n",
      "b2 relative error: 1.72e-09\n",
      "b3 relative error: 1.80e-10\n"
     ]
    }
   ],
   "source": [
    "np.random.seed(231)\n",
    "N, D, H1, H2, C = 2, 15, 20, 30, 10\n",
    "X = np.random.randn(N, D)\n",
    "y = np.random.randint(C, size=(N,))\n",
    "\n",
    "for reg in [0, 3.14]:\n",
    "  print('Running check with reg = ', reg)\n",
    "  model = FullyConnectedNet([H1, H2], input_dim=D, num_classes=C,\n",
    "                            reg=reg, weight_scale=5e-2, dtype=np.float64)\n",
    "\n",
    "  loss, grads = model.loss(X, y)\n",
    "  print('Initial loss: ', loss)\n",
    "  \n",
    "  # Most of the errors should be on the order of e-7 or smaller.   \n",
    "  # NOTE: It is fine however to see an error for W2 on the order of e-5\n",
    "  # for the check when reg = 0.0\n",
    "  for name in sorted(grads):\n",
    "    f = lambda _: model.loss(X, y)[0]\n",
    "    grad_num = eval_numerical_gradient(f, model.params[name], verbose=False, h=1e-5)\n",
    "    print('%s relative error: %.2e' % (name, rel_error(grad_num, grads[name])))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As another sanity check, make sure you can overfit a small dataset of 50 images. First we will try a three-layer network with 100 units in each hidden layer. In the following cell, tweak the learning rate and initialization scale to overfit and achieve 100% training accuracy within 20 epochs."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(Iteration 1 / 40) loss: 2.363364\n",
      "(Epoch 0 / 20) train acc: 0.020000; val_acc: 0.105000\n",
      "(Epoch 1 / 20) train acc: 0.020000; val_acc: 0.106000\n",
      "(Epoch 2 / 20) train acc: 0.020000; val_acc: 0.110000\n",
      "(Epoch 3 / 20) train acc: 0.020000; val_acc: 0.110000\n",
      "(Epoch 4 / 20) train acc: 0.040000; val_acc: 0.109000\n",
      "(Epoch 5 / 20) train acc: 0.040000; val_acc: 0.111000\n",
      "(Iteration 11 / 40) loss: 2.270022\n",
      "(Epoch 6 / 20) train acc: 0.040000; val_acc: 0.111000\n",
      "(Epoch 7 / 20) train acc: 0.060000; val_acc: 0.112000\n",
      "(Epoch 8 / 20) train acc: 0.060000; val_acc: 0.111000\n",
      "(Epoch 9 / 20) train acc: 0.040000; val_acc: 0.110000\n",
      "(Epoch 10 / 20) train acc: 0.040000; val_acc: 0.109000\n",
      "(Iteration 21 / 40) loss: 2.309562\n",
      "(Epoch 11 / 20) train acc: 0.060000; val_acc: 0.110000\n",
      "(Epoch 12 / 20) train acc: 0.060000; val_acc: 0.110000\n",
      "(Epoch 13 / 20) train acc: 0.060000; val_acc: 0.110000\n",
      "(Epoch 14 / 20) train acc: 0.060000; val_acc: 0.110000\n",
      "(Epoch 15 / 20) train acc: 0.060000; val_acc: 0.113000\n",
      "(Iteration 31 / 40) loss: 2.285026\n",
      "(Epoch 16 / 20) train acc: 0.060000; val_acc: 0.117000\n",
      "(Epoch 17 / 20) train acc: 0.080000; val_acc: 0.113000\n",
      "(Epoch 18 / 20) train acc: 0.080000; val_acc: 0.118000\n",
      "(Epoch 19 / 20) train acc: 0.100000; val_acc: 0.118000\n",
      "(Epoch 20 / 20) train acc: 0.100000; val_acc: 0.120000\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7f915809f668>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# TODO: Use a three-layer Net to overfit 50 training examples by \n",
    "# tweaking just the learning rate and initialization scale.\n",
    "\n",
    "num_train = 50\n",
    "small_data = {\n",
    "  'X_train': data['X_train'][:num_train],\n",
    "  'y_train': data['y_train'][:num_train],\n",
    "  'X_val': data['X_val'],\n",
    "  'y_val': data['y_val'],\n",
    "}\n",
    "\n",
    "weight_scale = 1e-2\n",
    "learning_rate = 1e-4\n",
    "model = FullyConnectedNet([100, 100],\n",
    "              weight_scale=weight_scale, dtype=np.float64)\n",
    "solver = Solver(model, small_data,\n",
    "                print_every=10, num_epochs=20, batch_size=25,\n",
    "                update_rule='sgd',\n",
    "                optim_config={\n",
    "                  'learning_rate': learning_rate,\n",
    "                }\n",
    "         )\n",
    "solver.train()\n",
    "\n",
    "plt.plot(solver.loss_history, 'o')\n",
    "plt.title('Training loss history')\n",
    "plt.xlabel('Iteration')\n",
    "plt.ylabel('Training loss')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now try to use a five-layer network with 100 units on each layer to overfit 50 training examples. Again you will have to adjust the learning rate and weight initialization, but you should be able to achieve 100% training accuracy within 20 epochs."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(Iteration 1 / 40) loss: 2.302585\n",
      "(Epoch 0 / 20) train acc: 0.160000; val_acc: 0.079000\n",
      "(Epoch 1 / 20) train acc: 0.160000; val_acc: 0.079000\n",
      "(Epoch 2 / 20) train acc: 0.160000; val_acc: 0.079000\n",
      "(Epoch 3 / 20) train acc: 0.160000; val_acc: 0.079000\n",
      "(Epoch 4 / 20) train acc: 0.160000; val_acc: 0.079000\n",
      "(Epoch 5 / 20) train acc: 0.160000; val_acc: 0.079000\n",
      "(Iteration 11 / 40) loss: 2.301962\n",
      "(Epoch 6 / 20) train acc: 0.160000; val_acc: 0.079000\n",
      "(Epoch 7 / 20) train acc: 0.160000; val_acc: 0.079000\n",
      "(Epoch 8 / 20) train acc: 0.160000; val_acc: 0.079000\n",
      "(Epoch 9 / 20) train acc: 0.160000; val_acc: 0.079000\n",
      "(Epoch 10 / 20) train acc: 0.160000; val_acc: 0.079000\n",
      "(Iteration 21 / 40) loss: 2.301859\n",
      "(Epoch 11 / 20) train acc: 0.160000; val_acc: 0.079000\n",
      "(Epoch 12 / 20) train acc: 0.160000; val_acc: 0.079000\n",
      "(Epoch 13 / 20) train acc: 0.160000; val_acc: 0.079000\n",
      "(Epoch 14 / 20) train acc: 0.160000; val_acc: 0.079000\n",
      "(Epoch 15 / 20) train acc: 0.160000; val_acc: 0.079000\n",
      "(Iteration 31 / 40) loss: 2.301798\n",
      "(Epoch 16 / 20) train acc: 0.160000; val_acc: 0.079000\n",
      "(Epoch 17 / 20) train acc: 0.160000; val_acc: 0.079000\n",
      "(Epoch 18 / 20) train acc: 0.160000; val_acc: 0.079000\n",
      "(Epoch 19 / 20) train acc: 0.160000; val_acc: 0.079000\n",
      "(Epoch 20 / 20) train acc: 0.160000; val_acc: 0.079000\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7f915809f6d8>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# TODO: Use a five-layer Net to overfit 50 training examples by \n",
    "# tweaking just the learning rate and initialization scale.\n",
    "\n",
    "num_train = 50\n",
    "small_data = {\n",
    "  'X_train': data['X_train'][:num_train],\n",
    "  'y_train': data['y_train'][:num_train],\n",
    "  'X_val': data['X_val'],\n",
    "  'y_val': data['y_val'],\n",
    "}\n",
    "\n",
    "learning_rate = 2e-3\n",
    "weight_scale = 1e-5\n",
    "model = FullyConnectedNet([100, 100, 100, 100],\n",
    "                weight_scale=weight_scale, dtype=np.float64)\n",
    "solver = Solver(model, small_data,\n",
    "                print_every=10, num_epochs=20, batch_size=25,\n",
    "                update_rule='sgd',\n",
    "                optim_config={\n",
    "                  'learning_rate': learning_rate,\n",
    "                }\n",
    "         )\n",
    "solver.train()\n",
    "\n",
    "plt.plot(solver.loss_history, 'o')\n",
    "plt.title('Training loss history')\n",
    "plt.xlabel('Iteration')\n",
    "plt.ylabel('Training loss')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Inline Question 2: \n",
    "Did you notice anything about the comparative difficulty of training the three-layer net vs training the five layer net? In particular, based on your experience, which network seemed more sensitive to the initialization scale? Why do you think that is the case?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Answer:\n",
    "[FILL THIS IN]\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Update rules\n",
    "So far we have used vanilla stochastic gradient descent (SGD) as our update rule. More sophisticated update rules can make it easier to train deep networks. We will implement a few of the most commonly used update rules and compare them to vanilla SGD."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# SGD+Momentum\n",
    "Stochastic gradient descent with momentum is a widely used update rule that tends to make deep networks converge faster than vanilla stochastic gradient descent. See the Momentum Update section at http://cs231n.github.io/neural-networks-3/#sgd for more information.\n",
    "\n",
    "Open the file `cs231n/optim.py` and read the documentation at the top of the file to make sure you understand the API. Implement the SGD+momentum update rule in the function `sgd_momentum` and run the following to check your implementation. You should see errors less than e-8."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "next_w error:  8.882347033505819e-09\n",
      "velocity error:  4.269287743278663e-09\n"
     ]
    }
   ],
   "source": [
    "from cs231n.optim import sgd_momentum\n",
    "\n",
    "N, D = 4, 5\n",
    "w = np.linspace(-0.4, 0.6, num=N*D).reshape(N, D)\n",
    "dw = np.linspace(-0.6, 0.4, num=N*D).reshape(N, D)\n",
    "v = np.linspace(0.6, 0.9, num=N*D).reshape(N, D)\n",
    "\n",
    "config = {'learning_rate': 1e-3, 'velocity': v}\n",
    "next_w, _ = sgd_momentum(w, dw, config=config)\n",
    "\n",
    "expected_next_w = np.asarray([\n",
    "  [ 0.1406,      0.20738947,  0.27417895,  0.34096842,  0.40775789],\n",
    "  [ 0.47454737,  0.54133684,  0.60812632,  0.67491579,  0.74170526],\n",
    "  [ 0.80849474,  0.87528421,  0.94207368,  1.00886316,  1.07565263],\n",
    "  [ 1.14244211,  1.20923158,  1.27602105,  1.34281053,  1.4096    ]])\n",
    "expected_velocity = np.asarray([\n",
    "  [ 0.5406,      0.55475789,  0.56891579, 0.58307368,  0.59723158],\n",
    "  [ 0.61138947,  0.62554737,  0.63970526,  0.65386316,  0.66802105],\n",
    "  [ 0.68217895,  0.69633684,  0.71049474,  0.72465263,  0.73881053],\n",
    "  [ 0.75296842,  0.76712632,  0.78128421,  0.79544211,  0.8096    ]])\n",
    "\n",
    "# Should see relative errors around e-8 or less\n",
    "print('next_w error: ', rel_error(next_w, expected_next_w))\n",
    "print('velocity error: ', rel_error(expected_velocity, config['velocity']))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Once you have done so, run the following to train a six-layer network with both SGD and SGD+momentum. You should see the SGD+momentum update rule converge faster."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "running with  sgd\n",
      "(Iteration 1 / 200) loss: 2.559978\n",
      "(Epoch 0 / 5) train acc: 0.103000; val_acc: 0.108000\n",
      "(Iteration 11 / 200) loss: 2.291086\n",
      "(Iteration 21 / 200) loss: 2.153591\n",
      "(Iteration 31 / 200) loss: 2.082693\n",
      "(Epoch 1 / 5) train acc: 0.277000; val_acc: 0.242000\n",
      "(Iteration 41 / 200) loss: 2.004171\n",
      "(Iteration 51 / 200) loss: 2.010409\n",
      "(Iteration 61 / 200) loss: 2.023753\n",
      "(Iteration 71 / 200) loss: 2.026621\n",
      "(Epoch 2 / 5) train acc: 0.352000; val_acc: 0.312000\n",
      "(Iteration 81 / 200) loss: 1.807163\n",
      "(Iteration 91 / 200) loss: 1.914256\n",
      "(Iteration 101 / 200) loss: 1.920494\n",
      "(Iteration 111 / 200) loss: 1.708877\n",
      "(Epoch 3 / 5) train acc: 0.399000; val_acc: 0.316000\n",
      "(Iteration 121 / 200) loss: 1.701111\n",
      "(Iteration 131 / 200) loss: 1.769697\n",
      "(Iteration 141 / 200) loss: 1.788899\n",
      "(Iteration 151 / 200) loss: 1.816437\n",
      "(Epoch 4 / 5) train acc: 0.419000; val_acc: 0.320000\n",
      "(Iteration 161 / 200) loss: 1.632625\n",
      "(Iteration 171 / 200) loss: 1.900479\n",
      "(Iteration 181 / 200) loss: 1.537285\n",
      "(Iteration 191 / 200) loss: 1.718430\n",
      "(Epoch 5 / 5) train acc: 0.434000; val_acc: 0.334000\n",
      "\n",
      "running with  sgd_momentum\n",
      "(Iteration 1 / 200) loss: 3.153778\n",
      "(Epoch 0 / 5) train acc: 0.105000; val_acc: 0.093000\n",
      "(Iteration 11 / 200) loss: 2.145874\n",
      "(Iteration 21 / 200) loss: 2.032562\n",
      "(Iteration 31 / 200) loss: 1.985848\n",
      "(Epoch 1 / 5) train acc: 0.311000; val_acc: 0.281000\n",
      "(Iteration 41 / 200) loss: 1.882354\n",
      "(Iteration 51 / 200) loss: 1.855372\n",
      "(Iteration 61 / 200) loss: 1.649133\n",
      "(Iteration 71 / 200) loss: 1.806095\n",
      "(Epoch 2 / 5) train acc: 0.418000; val_acc: 0.327000\n",
      "(Iteration 81 / 200) loss: 1.910182\n",
      "(Iteration 91 / 200) loss: 1.498891\n",
      "(Iteration 101 / 200) loss: 1.541414\n",
      "(Iteration 111 / 200) loss: 1.518918\n",
      "(Epoch 3 / 5) train acc: 0.452000; val_acc: 0.348000\n",
      "(Iteration 121 / 200) loss: 1.625224\n",
      "(Iteration 131 / 200) loss: 1.525426\n",
      "(Iteration 141 / 200) loss: 1.589254\n",
      "(Iteration 151 / 200) loss: 1.717800\n",
      "(Epoch 4 / 5) train acc: 0.462000; val_acc: 0.329000\n",
      "(Iteration 161 / 200) loss: 1.629645\n",
      "(Iteration 171 / 200) loss: 1.483021\n",
      "(Iteration 181 / 200) loss: 1.425358\n",
      "(Iteration 191 / 200) loss: 1.363338\n",
      "(Epoch 5 / 5) train acc: 0.537000; val_acc: 0.389000\n",
      "\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/human/anaconda3/envs/cs231n/lib/python3.6/site-packages/matplotlib/cbook/deprecation.py:106: MatplotlibDeprecationWarning: Adding an axes using the same arguments as a previous axes currently reuses the earlier instance.  In a future version, a new instance will always be created and returned.  Meanwhile, this warning can be suppressed, and the future behavior ensured, by passing a unique label to each axes instance.\n",
      "  warnings.warn(message, mplDeprecation, stacklevel=1)\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7f91581b2e80>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "num_train = 4000\n",
    "small_data = {\n",
    "  'X_train': data['X_train'][:num_train],\n",
    "  'y_train': data['y_train'][:num_train],\n",
    "  'X_val': data['X_val'],\n",
    "  'y_val': data['y_val'],\n",
    "}\n",
    "\n",
    "solvers = {}\n",
    "\n",
    "for update_rule in ['sgd', 'sgd_momentum']:\n",
    "  print('running with ', update_rule)\n",
    "  model = FullyConnectedNet([100, 100, 100, 100, 100], weight_scale=5e-2)\n",
    "\n",
    "  solver = Solver(model, small_data,\n",
    "                  num_epochs=5, batch_size=100,\n",
    "                  update_rule=update_rule,\n",
    "                  optim_config={\n",
    "                    'learning_rate': 1e-2,\n",
    "                  },\n",
    "                  verbose=True)\n",
    "  solvers[update_rule] = solver\n",
    "  solver.train()\n",
    "  print()\n",
    "\n",
    "plt.subplot(3, 1, 1)\n",
    "plt.title('Training loss')\n",
    "plt.xlabel('Iteration')\n",
    "\n",
    "plt.subplot(3, 1, 2)\n",
    "plt.title('Training accuracy')\n",
    "plt.xlabel('Epoch')\n",
    "\n",
    "plt.subplot(3, 1, 3)\n",
    "plt.title('Validation accuracy')\n",
    "plt.xlabel('Epoch')\n",
    "\n",
    "for update_rule, solver in list(solvers.items()):\n",
    "  plt.subplot(3, 1, 1)\n",
    "  plt.plot(solver.loss_history, 'o', label=update_rule)\n",
    "  \n",
    "  plt.subplot(3, 1, 2)\n",
    "  plt.plot(solver.train_acc_history, '-o', label=update_rule)\n",
    "\n",
    "  plt.subplot(3, 1, 3)\n",
    "  plt.plot(solver.val_acc_history, '-o', label=update_rule)\n",
    "  \n",
    "for i in [1, 2, 3]:\n",
    "  plt.subplot(3, 1, i)\n",
    "  plt.legend(loc='upper center', ncol=4)\n",
    "plt.gcf().set_size_inches(15, 15)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# RMSProp and Adam\n",
    "RMSProp [1] and Adam [2] are update rules that set per-parameter learning rates by using a running average of the second moments of gradients.\n",
    "\n",
    "In the file `cs231n/optim.py`, implement the RMSProp update rule in the `rmsprop` function and implement the Adam update rule in the `adam` function, and check your implementations using the tests below.\n",
    "\n",
    "**NOTE:** Please implement the _complete_ Adam update rule (with the bias correction mechanism), not the first simplified version mentioned in the course notes. \n",
    "\n",
    "[1] Tijmen Tieleman and Geoffrey Hinton. \"Lecture 6.5-rmsprop: Divide the gradient by a running average of its recent magnitude.\" COURSERA: Neural Networks for Machine Learning 4 (2012).\n",
    "\n",
    "[2] Diederik Kingma and Jimmy Ba, \"Adam: A Method for Stochastic Optimization\", ICLR 2015."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "next_w error:  9.524687511038133e-08\n",
      "cache error:  2.6477955807156126e-09\n"
     ]
    }
   ],
   "source": [
    "# Test RMSProp implementation\n",
    "from cs231n.optim import rmsprop\n",
    "\n",
    "N, D = 4, 5\n",
    "w = np.linspace(-0.4, 0.6, num=N*D).reshape(N, D)\n",
    "dw = np.linspace(-0.6, 0.4, num=N*D).reshape(N, D)\n",
    "cache = np.linspace(0.6, 0.9, num=N*D).reshape(N, D)\n",
    "\n",
    "config = {'learning_rate': 1e-2, 'cache': cache}\n",
    "next_w, _ = rmsprop(w, dw, config=config)\n",
    "\n",
    "expected_next_w = np.asarray([\n",
    "  [-0.39223849, -0.34037513, -0.28849239, -0.23659121, -0.18467247],\n",
    "  [-0.132737,   -0.08078555, -0.02881884,  0.02316247,  0.07515774],\n",
    "  [ 0.12716641,  0.17918792,  0.23122175,  0.28326742,  0.33532447],\n",
    "  [ 0.38739248,  0.43947102,  0.49155973,  0.54365823,  0.59576619]])\n",
    "expected_cache = np.asarray([\n",
    "  [ 0.5976,      0.6126277,   0.6277108,   0.64284931,  0.65804321],\n",
    "  [ 0.67329252,  0.68859723,  0.70395734,  0.71937285,  0.73484377],\n",
    "  [ 0.75037008,  0.7659518,   0.78158892,  0.79728144,  0.81302936],\n",
    "  [ 0.82883269,  0.84469141,  0.86060554,  0.87657507,  0.8926    ]])\n",
    "\n",
    "# You should see relative errors around e-7 or less\n",
    "print('next_w error: ', rel_error(expected_next_w, next_w))\n",
    "print('cache error: ', rel_error(expected_cache, config['cache']))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "next_w error:  1.1395691798535431e-07\n",
      "v error:  4.208314038113071e-09\n",
      "m error:  4.214963193114416e-09\n"
     ]
    }
   ],
   "source": [
    "# Test Adam implementation\n",
    "from cs231n.optim import adam\n",
    "\n",
    "N, D = 4, 5\n",
    "w = np.linspace(-0.4, 0.6, num=N*D).reshape(N, D)\n",
    "dw = np.linspace(-0.6, 0.4, num=N*D).reshape(N, D)\n",
    "m = np.linspace(0.6, 0.9, num=N*D).reshape(N, D)\n",
    "v = np.linspace(0.7, 0.5, num=N*D).reshape(N, D)\n",
    "\n",
    "config = {'learning_rate': 1e-2, 'm': m, 'v': v, 't': 5}\n",
    "next_w, _ = adam(w, dw, config=config)\n",
    "\n",
    "expected_next_w = np.asarray([\n",
    "  [-0.40094747, -0.34836187, -0.29577703, -0.24319299, -0.19060977],\n",
    "  [-0.1380274,  -0.08544591, -0.03286534,  0.01971428,  0.0722929],\n",
    "  [ 0.1248705,   0.17744702,  0.23002243,  0.28259667,  0.33516969],\n",
    "  [ 0.38774145,  0.44031188,  0.49288093,  0.54544852,  0.59801459]])\n",
    "expected_v = np.asarray([\n",
    "  [ 0.69966,     0.68908382,  0.67851319,  0.66794809,  0.65738853,],\n",
    "  [ 0.64683452,  0.63628604,  0.6257431,   0.61520571,  0.60467385,],\n",
    "  [ 0.59414753,  0.58362676,  0.57311152,  0.56260183,  0.55209767,],\n",
    "  [ 0.54159906,  0.53110598,  0.52061845,  0.51013645,  0.49966,   ]])\n",
    "expected_m = np.asarray([\n",
    "  [ 0.48,        0.49947368,  0.51894737,  0.53842105,  0.55789474],\n",
    "  [ 0.57736842,  0.59684211,  0.61631579,  0.63578947,  0.65526316],\n",
    "  [ 0.67473684,  0.69421053,  0.71368421,  0.73315789,  0.75263158],\n",
    "  [ 0.77210526,  0.79157895,  0.81105263,  0.83052632,  0.85      ]])\n",
    "\n",
    "# You should see relative errors around e-7 or less\n",
    "print('next_w error: ', rel_error(expected_next_w, next_w))\n",
    "print('v error: ', rel_error(expected_v, config['v']))\n",
    "print('m error: ', rel_error(expected_m, config['m']))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Once you have debugged your RMSProp and Adam implementations, run the following to train a pair of deep networks using these new update rules:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "running with  adam\n",
      "(Iteration 1 / 200) loss: 3.476928\n",
      "(Epoch 0 / 5) train acc: 0.126000; val_acc: 0.110000\n",
      "(Iteration 11 / 200) loss: 2.027712\n",
      "(Iteration 21 / 200) loss: 2.183358\n",
      "(Iteration 31 / 200) loss: 1.744257\n",
      "(Epoch 1 / 5) train acc: 0.363000; val_acc: 0.330000\n",
      "(Iteration 41 / 200) loss: 1.707951\n",
      "(Iteration 51 / 200) loss: 1.703835\n",
      "(Iteration 61 / 200) loss: 2.094758\n",
      "(Iteration 71 / 200) loss: 1.505557\n",
      "(Epoch 2 / 5) train acc: 0.419000; val_acc: 0.362000\n",
      "(Iteration 81 / 200) loss: 1.594429\n",
      "(Iteration 91 / 200) loss: 1.519017\n",
      "(Iteration 101 / 200) loss: 1.368522\n",
      "(Iteration 111 / 200) loss: 1.470400\n",
      "(Epoch 3 / 5) train acc: 0.460000; val_acc: 0.378000\n",
      "(Iteration 121 / 200) loss: 1.199064\n",
      "(Iteration 131 / 200) loss: 1.464704\n",
      "(Iteration 141 / 200) loss: 1.359863\n",
      "(Iteration 151 / 200) loss: 1.415068\n",
      "(Epoch 4 / 5) train acc: 0.521000; val_acc: 0.374000\n",
      "(Iteration 161 / 200) loss: 1.382818\n",
      "(Iteration 171 / 200) loss: 1.359900\n",
      "(Iteration 181 / 200) loss: 1.095947\n",
      "(Iteration 191 / 200) loss: 1.243088\n",
      "(Epoch 5 / 5) train acc: 0.572000; val_acc: 0.382000\n",
      "\n",
      "running with  rmsprop\n",
      "(Iteration 1 / 200) loss: 2.589166\n",
      "(Epoch 0 / 5) train acc: 0.119000; val_acc: 0.146000\n",
      "(Iteration 11 / 200) loss: 2.032921\n",
      "(Iteration 21 / 200) loss: 1.897931\n",
      "(Iteration 31 / 200) loss: 1.767816\n",
      "(Epoch 1 / 5) train acc: 0.373000; val_acc: 0.318000\n",
      "(Iteration 41 / 200) loss: 1.889267\n",
      "(Iteration 51 / 200) loss: 1.682879\n",
      "(Iteration 61 / 200) loss: 1.490141\n",
      "(Iteration 71 / 200) loss: 1.623310\n",
      "(Epoch 2 / 5) train acc: 0.432000; val_acc: 0.351000\n",
      "(Iteration 81 / 200) loss: 1.507987\n",
      "(Iteration 91 / 200) loss: 1.619558\n",
      "(Iteration 101 / 200) loss: 1.495320\n",
      "(Iteration 111 / 200) loss: 1.583854\n",
      "(Epoch 3 / 5) train acc: 0.479000; val_acc: 0.366000\n",
      "(Iteration 121 / 200) loss: 1.485016\n",
      "(Iteration 131 / 200) loss: 1.539614\n",
      "(Iteration 141 / 200) loss: 1.546333\n",
      "(Iteration 151 / 200) loss: 1.654800\n",
      "(Epoch 4 / 5) train acc: 0.520000; val_acc: 0.357000\n",
      "(Iteration 161 / 200) loss: 1.601834\n",
      "(Iteration 171 / 200) loss: 1.427366\n",
      "(Iteration 181 / 200) loss: 1.495700\n",
      "(Iteration 191 / 200) loss: 1.389828\n",
      "(Epoch 5 / 5) train acc: 0.529000; val_acc: 0.371000\n",
      "\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/human/anaconda3/envs/cs231n/lib/python3.6/site-packages/matplotlib/cbook/deprecation.py:106: MatplotlibDeprecationWarning: Adding an axes using the same arguments as a previous axes currently reuses the earlier instance.  In a future version, a new instance will always be created and returned.  Meanwhile, this warning can be suppressed, and the future behavior ensured, by passing a unique label to each axes instance.\n",
      "  warnings.warn(message, mplDeprecation, stacklevel=1)\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7f9158145cf8>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "learning_rates = {'rmsprop': 1e-4, 'adam': 1e-3}\n",
    "for update_rule in ['adam', 'rmsprop']:\n",
    "  print('running with ', update_rule)\n",
    "  model = FullyConnectedNet([100, 100, 100, 100, 100], weight_scale=5e-2)\n",
    "\n",
    "  solver = Solver(model, small_data,\n",
    "                  num_epochs=5, batch_size=100,\n",
    "                  update_rule=update_rule,\n",
    "                  optim_config={\n",
    "                    'learning_rate': learning_rates[update_rule]\n",
    "                  },\n",
    "                  verbose=True)\n",
    "  solvers[update_rule] = solver\n",
    "  solver.train()\n",
    "  print()\n",
    "\n",
    "plt.subplot(3, 1, 1)\n",
    "plt.title('Training loss')\n",
    "plt.xlabel('Iteration')\n",
    "\n",
    "plt.subplot(3, 1, 2)\n",
    "plt.title('Training accuracy')\n",
    "plt.xlabel('Epoch')\n",
    "\n",
    "plt.subplot(3, 1, 3)\n",
    "plt.title('Validation accuracy')\n",
    "plt.xlabel('Epoch')\n",
    "\n",
    "for update_rule, solver in list(solvers.items()):\n",
    "  plt.subplot(3, 1, 1)\n",
    "  plt.plot(solver.loss_history, 'o', label=update_rule)\n",
    "  \n",
    "  plt.subplot(3, 1, 2)\n",
    "  plt.plot(solver.train_acc_history, '-o', label=update_rule)\n",
    "\n",
    "  plt.subplot(3, 1, 3)\n",
    "  plt.plot(solver.val_acc_history, '-o', label=update_rule)\n",
    "  \n",
    "for i in [1, 2, 3]:\n",
    "  plt.subplot(3, 1, i)\n",
    "  plt.legend(loc='upper center', ncol=4)\n",
    "plt.gcf().set_size_inches(15, 15)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Inline Question 3:\n",
    "\n",
    "AdaGrad, like Adam, is a per-parameter optimization method that uses the following update rule:\n",
    "\n",
    "```\n",
    "cache += dw**2\n",
    "w += - learning_rate * dw / (np.sqrt(cache) + eps)\n",
    "```\n",
    "\n",
    "John notices that when he was training a network with AdaGrad that the updates became very small, and that his network was learning slowly. Using your knowledge of the AdaGrad update rule, why do you think the updates would become very small? Would Adam have the same issue?\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Answer: \n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Train a good model!\n",
    "Train the best fully-connected model that you can on CIFAR-10, storing your best model in the `best_model` variable. We require you to get at least 50% accuracy on the validation set using a fully-connected net.\n",
    "\n",
    "If you are careful it should be possible to get accuracies above 55%, but we don't require it for this part and won't assign extra credit for doing so. Later in the assignment we will ask you to train the best convolutional network that you can on CIFAR-10, and we would prefer that you spend your effort working on convolutional nets rather than fully-connected nets.\n",
    "\n",
    "You might find it useful to complete the `BatchNormalization.ipynb` and `Dropout.ipynb` notebooks before completing this part, since those techniques can help you train powerful models."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true,
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "best_model = None\n",
    "################################################################################\n",
    "# TODO: Train the best FullyConnectedNet that you can on CIFAR-10. You might   #\n",
    "# find batch/layer normalization and dropout useful. Store your best model in  #\n",
    "# the best_model variable.                                                     #\n",
    "################################################################################\n",
    "pass\n",
    "################################################################################\n",
    "#                              END OF YOUR CODE                                #\n",
    "################################################################################"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Test your model!\n",
    "Run your best model on the validation and test sets. You should achieve above 50% accuracy on the validation set."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "y_test_pred = np.argmax(best_model.loss(data['X_test']), axis=1)\n",
    "y_val_pred = np.argmax(best_model.loss(data['X_val']), axis=1)\n",
    "print('Validation set accuracy: ', (y_val_pred == data['y_val']).mean())\n",
    "print('Test set accuracy: ', (y_test_pred == data['y_test']).mean())"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}
